from comunidadcyt.Publicaciones.forms import RevistasForms,ConferenciasForms,\
    LibrosForms,TesisForms,ReportesTecnicosForms,PapersForms,\
    crearAutoresForms, listarAutoresForms, BuscarPubForm
from django.core.context_processors import csrf
from django.shortcuts import render_to_response, HttpResponseRedirect
from comunidadcyt.Publicaciones.models import Libros, Revistas, Conferencias,\
    Tesis,ReportesTecnicos,Papers,Autores_de_publicaciones
from comunidadcyt.util.permisos import puedeCrearPublicacion, puedeEditarPublicacionEspecifica
from django.core.exceptions import ObjectDoesNotExist
from django.views.generic.create_update import delete_object
from django.core.urlresolvers import reverse
from django.template.context import RequestContext
from django.http import HttpResponse
from django.utils import simplejson
from django.db.models import Q

def create_publication_view(request,type):
    if puedeCrearPublicacion(request.user):
        c = {}
        c.update(csrf(request))
        c.update({'user':request.user})
        c.update({'type':type})
        c.update({'operation':'create'})

        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Crear Publicacion',request.path)])

        if request.method == 'POST':
            res_list = []
            f = None
            if type == 'libro':
                f = LibrosForms(request.user, request.POST, request.FILES)
                c.update({'form_libros':f})
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
            elif type == 'revista':
                f = RevistasForms(request.user, request.POST, request.FILES)
                c.update({'form_revistas':f})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
            elif type == 'conferencia':
                f = ConferenciasForms(request.user, request.POST, request.FILES)
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_conferencias':f})
            elif type == 'tesis':
                f = TesisForms(request.user, request.POST, request.FILES)
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_tesis':f})
            elif type == 'reporte':
                f = ReportesTecnicosForms(request.user, request.POST, request.FILES)
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_reportes':f})
            elif type == 'paper':
                f = PapersForms(request.user, request.POST, request.FILES)
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                c.update({'form_papers':f})

            if f.is_valid():
                pub = f.save()
                return HttpResponseRedirect(reverse(edit_publication_view,args=[type, pub.id]))
            else:
                c.update({'type': type})
                for item in res_list:
                    c.update(item)
                return render_to_response('Publicaciones/create.html',c,context_instance = RequestContext(request))
        else:
            form_revistas =  RevistasForms(user=request.user)
            form_conferencias = ConferenciasForms(user=request.user)
            form_libros = LibrosForms(user=request.user)
            form_tesis = TesisForms(user=request.user)
            form_reportes = ReportesTecnicosForms(user=request.user)
            form_papers = PapersForms(user=request.user)


        c.update({'form_libros':form_libros})
        c.update({'form_revistas':form_revistas})
        c.update({'form_conferencias':form_conferencias})
        c.update({'form_tesis':form_tesis})
        c.update({'form_reportes':form_reportes})
        c.update({'form_papers':form_papers})

        return render_to_response('Publicaciones/create.html',c,context_instance = RequestContext(request))

    return HttpResponseRedirect("/comunidadcyt/login/")

def edit_publication_view(request,type,pub_id):
    c = {}
    c.update(csrf(request))
    c.update({'user':request.user})
    c.update({'operation':'edit'})
    c.update({'obj_id':pub_id})
   
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Editar Publicacion',request.path)])
    pub = None
    if type == 'libro':
        pub = Libros.objects.get(pk=pub_id)
    elif type == 'revista':
        pub = Revistas.objects.get(pk=pub_id)
    elif type == 'conferencia':
        pub = Conferencias.objects.get(pk=pub_id)
    elif type == 'tesis':
        pub = Tesis.objects.get(pk=pub_id)
    elif type == 'reporte':
        pub = ReportesTecnicos.objects.get(pk=pub_id)  
    elif type == 'paper':
        pub = Papers.objects.get(pk=pub_id)

    if estaEnListaAutoresInternos(request.user, pub) or request.user.is_superuser or request.user.username == pub.creado_por:
        if request.method == 'POST':
            res_list = []
            f = None
            if type == 'libro':
                f = LibrosForms(request.user, request.POST,request.FILES,instance = Libros.objects.get(pk=pub_id))
                c.update({'form_libros':f})
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
            elif type == 'revista':
                f = RevistasForms(request.user, request.POST,request.FILES,instance = Revistas.objects.get(pk=pub_id))
                c.update({'form_revistas':f})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
            elif type == 'conferencia':
                f = ConferenciasForms(request.user, request.POST,request.FILES,instance = Conferencias.objects.get(pk=pub_id))
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_conferencias':f})
            elif type == 'tesis':
                f = TesisForms(request.user, request.POST,request.FILES,instance = Tesis.objects.get(pk=pub_id))
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_tesis':f})
            elif type == 'reporte':
                f = ReportesTecnicosForms(request.user, request.POST,request.FILES,instance = ReportesTecnicos.objects.get(pk=pub_id))
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_papers':PapersForms(user=request.user)})
                c.update({'form_reportes':f})    
            elif type == 'paper':
                f = PapersForms(request.user, request.POST, request.FILES,instance = Papers.objects.get(pk=pub_id))
                res_list.append({'form_revistas':RevistasForms(user=request.user)})
                res_list.append({'form_libros':LibrosForms(user=request.user)})
                res_list.append({'form_conferencias':ConferenciasForms(user=request.user)})
                res_list.append({'form_tesis':TesisForms(user=request.user)})
                res_list.append({'form_reportes':ReportesTecnicosForms(user=request.user)})
                c.update({'form_papers':f})
               
            if f.is_valid():
                f.save()            
                return render_to_response('Publicaciones/success.html',c,context_instance = RequestContext(request))
            else:
                c.update({'type':type})
                for item in res_list:
                    c.update(item)
                return render_to_response('Publicaciones/create.html',c,context_instance = RequestContext(request))
        else:
            form_listar_autores = None
            if type == 'revista':
                form_revistas =  RevistasForms(user=request.user, instance = Revistas.objects.get(id = pub_id))
                c.update({'form_revistas':form_revistas})
                form_listar_autores = listarAutoresForms(pub_obj = Revistas.objects.get(id = pub_id))
            elif type == 'conferencia':
                form_conferencias = ConferenciasForms(user=request.user, instance = Conferencias.objects.get(id = pub_id))
                c.update({'form_conferencias':form_conferencias})
                form_listar_autores = listarAutoresForms(pub_obj = Conferencias.objects.get(id = pub_id))
            elif type == 'libro':
                form_libros = LibrosForms(user=request.user, instance = Libros.objects.get(id = pub_id))
                c.update({'form_libros':form_libros})
                form_listar_autores = listarAutoresForms(pub_obj = Libros.objects.get(id = pub_id))
            elif type == 'paper':
                form_papers = PapersForms(user=request.user, instance = Papers.objects.get(id = pub_id))
                c.update({'form_papers':form_papers})
                form_listar_autores = listarAutoresForms(pub_obj = Papers.objects.get(id = pub_id))
            elif type == 'reporte':
                form_reportes = ReportesTecnicosForms(user=request.user, instance = ReportesTecnicos.objects.get(id = pub_id))
                c.update({'form_reportes':form_reportes})
                form_listar_autores = listarAutoresForms(pub_obj = ReportesTecnicos.objects.get(id = pub_id))
            elif type == 'tesis':
                form_tesis = TesisForms(user=request.user, instance = Tesis.objects.get(id = pub_id))
                c.update({'form_tesis':form_tesis})  
                form_listar_autores = listarAutoresForms(pub_obj = Tesis.objects.get(id = pub_id))
            c.update({'form_listar_autores':form_listar_autores})  
            form_crear_autores = crearAutoresForms()
            c.update({'form_crear_autores':form_crear_autores})
            c.update({'type':type})
       
        return render_to_response('Publicaciones/create.html',c,context_instance = RequestContext(request))

    return HttpResponseRedirect("/comunidadcyt/login/")

def filterLibro(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = Libros.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(libro__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = Libros.objects.filter(
                Q(libro__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = Libros.objects.all()

    return dbfilter

def filterRevista(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = Revistas.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(revista__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = Revistas.objects.filter(
                Q(revista__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = Revistas.objects.all()

    return dbfilter

def filterConferencia(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = Conferencias.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(conferencia__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = Conferencias.objects.filter(
                Q(conferencia__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = Conferencias.objects.all()

    return dbfilter

def filterTesis(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = Tesis.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(titulo_tesis__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = Tesis.objects.filter(
                Q(titulo_tesis__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = Tesis.objects.all()

    return dbfilter

def filterPaper(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = Papers.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(paper__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = Papers.objects.filter(
                Q(paper__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = Papers.objects.all()

    return dbfilter

def filterReporte(request, autor, titulo):
    dbfilter = None

    if autor and autor != "":
        dbfilter = ReportesTecnicos.objects.filter(
            Q(autores__autor_interno__first_name__contains=autor) |
            Q(autores__autor_interno__last_name__contains=autor) |
            Q(autores__autor_externo__contains=autor) |
            Q(creado_por__contains=autor)
        ).distinct()

    if titulo and titulo != "":
        if dbfilter:
            dbfilter = dbfilter.filter(
                Q(reporte__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()
        else:
            dbfilter = ReportesTecnicos.objects.filter(
                Q(reporte__contains=titulo) |
                Q(publicacion__contains=titulo)
            ).distinct()

    if dbfilter is None:
        dbfilter = ReportesTecnicos.objects.all()

    return dbfilter

def filterPrivacy(request, listPubs):
    filteredList = []

    for pub in listPubs:
        if request.user.is_authenticated and request.user.id > 0:
            found = False
            if pub.privacidad == "grupos":
                for bg in pub.grupos.all():
                    for g in request.user.grupos.all():
                        if bg.id == g.id:
                            filteredList.append(pub)
                            found = True
                            break
                    if found:
                        break
                    else:
                        continue
            elif pub.privacidad == "autores":
                if estaEnListaAutoresInternos(request.user, pub) or request.user.username == pub.creado_por:
                    filteredList.append(pub)
                    break
                else:
                    continue
            elif pub.privacidad == "proyectos":
                for bp in pub.proyectos.all():
                    for p in request.user.proyectos.all():
                        if bp.id == p.id:
                            filteredList.append(pub)
                            found = True
                            break
                    if found:
                        break
                    else:
                        continue
            elif pub.privacidad == "departamentos":
                for bd in pub.departamentos.all():
                    for d in request.user.departamentos.all():
                        if bd.id == d.id:
                            filteredList.append(pub)
                            found = True
                            break
                    if found:
                        break
                    else:
                        continue
            elif pub.privacidad == "sin_privacidad":
                filteredList.append(pub)
        else:
            if pub.privacidad == "sin_privacidad":
                filteredList.append(pub)
    return filteredList

def filtrarBusqueda(request, pubs, autor, titulo, tipo):
    if tipo == 'Libro' or tipo == 'Todos':
        pubs.update({'books': filterPrivacy(request, filterLibro(request, autor, titulo))})
    if tipo == 'Revista' or tipo == 'Todos':
        pubs.update({'magazines': filterPrivacy(request, filterRevista(request, autor, titulo))})
    if tipo == 'Conferencia' or tipo == 'Todos':
        pubs.update({'conferences': filterPrivacy(request, filterConferencia(request, autor, titulo))})
    if tipo == 'Tesis' or tipo == 'Todos':
        pubs.update({'tesis': filterPrivacy(request, filterTesis(request, autor, titulo))})
    if tipo == 'Paper' or tipo == 'Todos':
        pubs.update({'papers': filterPrivacy(request, filterPaper(request, autor, titulo))})
    if tipo == 'Reporte Tecnico' or tipo == 'Todos':
        pubs.update({'reports': filterPrivacy(request, filterReporte(request, autor, titulo))})

    return pubs

def buscarPublicaciones(request):
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Buscar Publicaciones', request.path)])
    if request.method == "GET":
        c = {'formSearch': BuscarPubForm()}
        return render_to_response('Publicaciones/list.html', c, context_instance = RequestContext(request))
    if request.method == "POST":
        form = BuscarPubForm(request.POST)
        autor = form.data['autor']
        titulo = form.data['titulo']
        tipo = form.data['tipo']

        pubs = {}
        pubs.update({'books':[]})
        pubs.update({'magazines':[]})
        pubs.update({'conferences':[]})
        pubs.update({'tesis':[]})
        pubs.update({'papers':[]})
        pubs.update({'reports':[]})

        templateData = filtrarBusqueda(request, pubs, autor, titulo, tipo)
        templateData.update({'formSearch': BuscarPubForm()})

        return render_to_response('Publicaciones/list.html', templateData, context_instance = RequestContext(request))

    return HttpResponseRedirect("/comunidadcyt/publicaciones/listar/")

def mis_publicaciones_view(request):
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)), ('Mis Publicaciones', request.path)])

    pubs = {}
    pubs.update({'books':Libros.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})
    pubs.update({'magazines':Revistas.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})
    pubs.update({'conferences':Conferencias.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})
    pubs.update({'tesis':Tesis.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})
    pubs.update({'papers':Papers.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})
    pubs.update({'reports':ReportesTecnicos.objects.filter(Q(creado_por=request.user.username) | Q(autores__autor_interno__id__exact=request.user.id)).distinct()})

    pubs.update({'notShowSearchForm': True})

    return render_to_response('Publicaciones/list.html', pubs, context_instance = RequestContext(request))

def list_all_publications_view(request):
    return HttpResponseRedirect("/comunidadcyt/publicaciones/buscarPublicaciones/")

def getNoneOrPublicationFilterByPerm(request, pub):
    if pub.privacidad == "sin_privacidad" and pub:
        return pub

    if request.user.is_authenticated():
        if request.user.username == pub.creado_por:
            return pub
        elif pub.privacidad == "grupos":
            for mg in pub.grupos.all():
                for g in request.user.grupos.all():
                    if mg.id == g.id:
                        return pub
        elif pub.privacidad == "autores":
            if estaEnListaAutoresInternos(request.user, pub) or request.user.username == pub.creado_por:
                return pub
        elif pub.privacidad == "proyectos":
            for mp in pub.proyectos.all():
                for p in request.user.proyectos.all():
                    if mp.id == p.id:
                        return pub
        elif pub.privacidad == "departamentos":
            for md in pub.departamentos.all():
                for d in request.user.departamentos.all():
                    if md.id == d.id:
                        return pub
    return None

def obtenerRevista(request,object_id):
    try:
        pub = Revistas.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesRevista(request,object_id):
    revista = obtenerRevista(request, object_id)
    if not revista:
        return render_to_response('error.html',{'error':'No existe el objeto revista.', 'archivo': 'view de publicaciones', 'linea': 'linea 21'})

    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Revista',request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Revista',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+revista.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+revista.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesRevista.html', {
        'Revista': revista,
        'Publicacion': revista,
        'tipo':"revista",
        'user': request.user,
        'puedeEditar': puedeEditarPublicacionEspecifica(request.user, revista)},
        context_instance=RequestContext(request)
    )


def obtenerConferencia(request,object_id):
    try:
        pub = Conferencias.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesConferencia(request,object_id):
    conferencia = obtenerConferencia(request, object_id)
    if not conferencia:
        return render_to_response('error.html',{'error':'No existe el objeto conferencia.', 'archivo': 'view de publicaciones', 'linea': 'linea 35'})
    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Conferencia', request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Conferencia',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+conferencia.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+conferencia.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesConferencia.html', {
        'Conferencia': conferencia,
        'Publicacion': conferencia,
        'tipo':"conferencia",
        'user': request.user,
        'puedeEditar': puedeEditarPublicacionEspecifica(request.user, conferencia)},
        context_instance=RequestContext(request)
    )

def obtenerLibros(request,object_id):
    try:
        pub = Libros.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesLibro(request,object_id):
    libro = obtenerLibros(request, object_id)
    if not libro:
        return render_to_response('error.html',{'error':'No existe el objeto libro.', 'archivo': 'view de publicaciones', 'linea': 'linea 802'})
    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Libro',request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Libro',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+libro.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+libro.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesLibro.html', {
        'Libro': libro,
        'Publicacion': libro,
        'tipo':"libro",
        'user': request.user,
        'puedeEditar': puedeEditarPublicacionEspecifica(request.user, libro)},
        context_instance=RequestContext(request)
    )

def obtenerTesis(request,object_id):
    try:
        pub = Tesis.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesTesis(request,object_id):
    tesis = obtenerTesis(request, object_id)
    if not tesis:
        return render_to_response('error.html',{'error':'No existe el objeto tesis.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})
    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Tesis',request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Tesis',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+libro.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+libro.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesTesis.html', {'Tesis': tesis, 
                                                                   'Publicacion': tesis,
                                                                   'tipo':"tesis", 
                                                                   'user': request.user,
                                                                   'puedeEditar': puedeEditarPublicacionEspecifica(request.user, tesis)},
                                                                   context_instance=RequestContext(request))

def obtenerPapers(request,object_id):
    try:
        pub = Papers.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesPaper(request,object_id):
    paper = obtenerPapers(request, object_id)
    if not paper:
        return render_to_response('error.html',{'error':'No existe el objeto paper.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})
    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Paper',request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Paper',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+libro.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+libro.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesPaper.html', {'Paper': paper,
                                                                   'Publicacion': paper,
                                                                   'tipo':"paper",  
                                                                   'user': request.user,
                                                                   'puedeEditar': puedeEditarPublicacionEspecifica(request.user, paper)},
                                                                   context_instance=RequestContext(request))

def obtenerReporte(request,object_id):
    try:
        pub = ReportesTecnicos.objects.get(id=object_id)
        return getNoneOrPublicationFilterByPerm(request, pub)
    except Exception:
        return None

def detallesReporte(request,object_id):
    reporte = obtenerReporte(request, object_id)
    if not reporte:
        return render_to_response('error.html',{'error':'No existe el objeto reporte.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})
    try:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Reporte',request.path)])
    except ObjectDoesNotExist:
        request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Ver Reporte',request.path)])
    #===========================================================================
    # if 'HTTP_REFERER' in request.META:
    #    request.breadcrumbs([('Publicaciones',request.META['HTTP_REFERER']),('Ver '+libro.titulo,request.path)])
    # else:
    #    request.breadcrumbs([('Ver '+libro.titulo,request.path)])
    #===========================================================================
    return render_to_response('Publicaciones/detallesReporte.html', {'Reporte': reporte, 
                                                                     'Publicacion': reporte,
                                                                     'tipo':"reporte", 
                                                                     'user': request.user,
                                                                     'puedeEditar': puedeEditarPublicacionEspecifica(request.user, reporte)},
                                                                     context_instance=RequestContext(request))

def borrarRevista(request,object_id):
    revista = obtenerRevista(request, object_id)
    if not revista:
        return render_to_response('error.html',{'error':'No existe el objeto revista.', 'archivo': 'view de publicaciones', 'linea': 'linea 21'})

    if puedeEditarPublicacionEspecifica(request.user, revista):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Revista',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Revista',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        return delete_object(
            request,
            model = Revistas,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")

def borrarConferencia(request,object_id):
    conferencia = obtenerConferencia(request, object_id)
    if not conferencia:
        return render_to_response('error.html',{'error':'No existe el objeto conferencia.', 'archivo': 'view de publicaciones', 'linea': 'linea 35'})

    if puedeEditarPublicacionEspecifica(request.user, conferencia):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Conferencia',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Conferencia',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        return delete_object(
            request,
            model = Conferencias,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")

def borrarLibro(request,object_id):
    libro = obtenerLibros(request, object_id)
    if not libro:
        return render_to_response('error.html',{'error':'No existe el objeto libro.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})

    if puedeEditarPublicacionEspecifica(request.user, libro):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Libro',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Libro',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'

        return delete_object(
            request,
            model = Libros,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")
   
def borrarReporte(request,object_id):
    reporte = obtenerReporte(request, object_id)
    if not reporte:
        return render_to_response('error.html',{'error':'No existe el objeto reporte.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})

    if puedeEditarPublicacionEspecifica(request.user, reporte):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Reporte',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Reporte',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        return delete_object(
            request,
            model = ReportesTecnicos,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")
   
def borrarTesis(request,object_id):
    tesis = obtenerTesis(request, object_id)
    if not tesis:
        return render_to_response('error.html',{'error':'No existe el objeto tesis.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})

    if puedeEditarPublicacionEspecifica(request.user, tesis):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Tesis',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Tesis',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        return delete_object(
            request,
            model = Tesis,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")
   
def borrarPaper(request,object_id):
    paper = obtenerPapers(request, object_id)
    if not paper:
        return render_to_response('error.html',{'error':'No existe el objeto paper.', 'archivo': 'view de publicaciones', 'linea': 'linea 50'})

    if puedeEditarPublicacionEspecifica(request.user, paper):
        try:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Paper',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        except ObjectDoesNotExist:
            request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Borrar Paper',request.path)])
            direccion = '/comunidadcyt/publicaciones/listar/'
        return delete_object(
            request,
            model = Papers,
            template_name = 'Publicaciones/confirm_delete.html',
            post_delete_redirect = direccion,
            object_id = object_id
        )

    return HttpResponseRedirect("/comunidadcyt/login/")

def obtenerDeptos(publicacion):
    list_grupos = list(publicacion.grupos.all())
    list_departamentos = list(publicacion.departamentos.all())
    for proyecto in publicacion.proyectos.all():
        for obj in proyecto.Departamentos.all():
            if not list_departamentos.__contains__(obj):
                list_departamentos.append(obj)
        for proy in proyecto.Grupos.all():
            if not list_grupos.__contains__(proy):
                list_grupos += [proy]
    for grupo in list_grupos:
        if not list_departamentos.__contains__(grupo.Departamento):
            list_departamentos += [grupo.Departamento]
    return list_departamentos
   
def obtenerGrupos(publicacion):
    list_grupos = list(publicacion.grupos.all())
    for proyecto in publicacion.proyectos.all():
        for proy in proyecto.Grupos.all():
            if not list_grupos.__contains__(proy):
                list_grupos += [proy]
    return list_grupos

def obtenerAutores(publicacion):
    return list(publicacion.autores.all())

def obtenerAutoresInternos(publicacion):
    lista = []
    for aut in publicacion.autores.all():
        if aut.autor_interno:
            lista.append(aut.autor_interno)
    return lista

def estaEnListaAutoresInternos(user, publicacion):
    if user and publicacion:
        for u in obtenerAutoresInternos(publicacion):
            if u.id == user.id:
                return True
    return False

def obtenerPartners(publicacion):
    list_partners = []
    for proyecto in publicacion.proyectos.all():
        for part in proyecto.Partners.all():
            if not list_partners.__contains__(part):
                list_partners += [part]
    return list_partners

def listardeptosLibros(request, object_id=0):
    libro = obtenerLibros(request, object_id)
    tipo = "libro"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+libro.libro,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Libro': libro,'Publicacion': libro, 'list_deptos': obtenerDeptos(libro), 'user': request.user}, context_instance=RequestContext(request))

def listargruposLibros(request, object_id=0):
    libro = obtenerLibros(request, object_id)
    tipo = "libro"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+libro.libro,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Libro': libro,'Publicacion': libro, 'list_grupos': obtenerGrupos(libro), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosLibros(request, object_id=0):
    libro = obtenerLibros(request, object_id)
    tipo = "libro"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+libro.libro,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Libro': libro, 'Publicacion': libro,'list_proyectos': libro.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersLibros(request, object_id=0):
    libro = obtenerLibros(request, object_id)
    tipo = "libro"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+libro.libro,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Libro': libro, 'Publicacion': libro,'list_partners': obtenerPartners(libro), 'user': request.user}, context_instance=RequestContext(request))

def listardeptosPapers(request, object_id=0):
    paper = obtenerPapers(request, object_id)
    tipo = "paper"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+paper.paper,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Paper': paper,'Publicacion': paper, 'list_deptos': obtenerDeptos(paper), 'user': request.user}, context_instance=RequestContext(request))

def listargruposPapers(request, object_id=0):
    paper = obtenerPapers(request, object_id)
    tipo = "paper"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+paper.paper,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Paper': paper, 'Publicacion': paper,'list_grupos': obtenerGrupos(paper), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosPapers(request, object_id=0):
    paper = obtenerPapers(request, object_id)
    tipo = "paper"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+paper.paper,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Paper': paper,'Publicacion': paper, 'list_proyectos': paper.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersPapers(request, object_id=0):
    paper = obtenerPapers(request, object_id)
    tipo = "paper"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+paper.paper,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Paper': paper, 'Publicacion': paper,'list_partners': obtenerPartners(paper), 'user': request.user}, context_instance=RequestContext(request))

def listardeptosTesis(request, object_id=0):
    tesis = obtenerTesis(request, object_id)
    tipo = "tesis"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+tesis.titulo_tesis,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Tesis': tesis,'Publicacion': tesis, 'list_deptos': obtenerDeptos(tesis), 'user': request.user}, context_instance=RequestContext(request))

def listargruposTesis(request, object_id=0):
    tesis = obtenerTesis(request, object_id)
    tipo = "tesis"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+tesis.titulo_tesis,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Tesis': tesis,'Publicacion': tesis, 'list_grupos': obtenerGrupos(tesis), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosTesis(request, object_id=0):
    tesis = obtenerTesis(request, object_id)
    tipo = "tesis"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+tesis.titulo_tesis,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Tesis': tesis, 'Publicacion': tesis,'list_proyectos': tesis.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersTesis(request, object_id=0):
    tesis = obtenerTesis(request, object_id)
    tipo = "tesis"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+tesis.titulo_tesis,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Tesis': tesis,'Publicacion': tesis, 'list_partners': obtenerPartners(tesis), 'user': request.user}, context_instance=RequestContext(request))

def listardeptosConferencias(request, object_id=0):
    conferencia = obtenerConferencia(request, object_id)
    tipo = "conferencia"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+conferencia.conferencia,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Conferencia': conferencia,'Publicacion': conferencia, 'list_deptos': obtenerDeptos(conferencia), 'user': request.user}, context_instance=RequestContext(request))

def listargruposConferencias(request, object_id=0):
    conferencia = obtenerConferencia(request, object_id)
    tipo = "conferencia"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+conferencia.conferencia,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Conferencia': conferencia, 'Publicacion': conferencia,'list_grupos': obtenerGrupos(conferencia), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosConferencias(request, object_id=0):
    conferencia = obtenerConferencia(request, object_id)
    tipo = "conferencia"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+conferencia.conferencia,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Conferencia': conferencia,'Publicacion': conferencia, 'list_proyectos': conferencia.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersConferencias(request, object_id=0):
    conferencia = obtenerConferencia(request, object_id)
    tipo = "conferencia"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+conferencia.conferencia,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Conferencia': conferencia, 'Publicacion': conferencia,'list_partners': obtenerPartners(conferencia), 'user': request.user}, context_instance=RequestContext(request))

def listardeptosRevistas(request, object_id=0):
    revista = obtenerRevista(request, object_id)
    tipo = "revista"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+revista.revista,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Revista': revista,'Publicacion': revista, 'list_deptos': obtenerDeptos(revista), 'user': request.user}, context_instance=RequestContext(request))

def listargruposRevistas(request, object_id=0):
    revista = obtenerRevista(request, object_id)
    tipo = "revista"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+revista.revista,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Revista': revista, 'Publicacion': revista,'list_grupos': obtenerGrupos(revista), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosRevistas(request, object_id=0):
    revista = obtenerRevista(request, object_id)
    tipo = "revista"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+revista.revista,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Revista': revista,'Publicacion': revista, 'list_proyectos': revista.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersRevistas(request, object_id=0):
    revista = obtenerRevista(request, object_id)
    tipo = "revista"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+revista.revista,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Revista': revista, 'Publicacion': revista,'list_partners': obtenerPartners(revista), 'user': request.user}, context_instance=RequestContext(request))

def listardeptosReportes(request, object_id=0):
    reporte = obtenerReporte(request, object_id)
    tipo = "reporte"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Departamentos '+reporte.reporte,request.path)])
    return render_to_response('Publicaciones/deptos.html', {'tipo':tipo,'Reporte': reporte,'Publicacion': reporte, 'list_deptos': obtenerDeptos(reporte), 'user': request.user}, context_instance=RequestContext(request))

def listargruposReportes(request, object_id=0):
    reporte = obtenerReporte(request, object_id)
    tipo = "reporte"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Grupos '+reporte.reporte,request.path)])
    return render_to_response('Publicaciones/grupos.html', {'tipo':tipo,'Reporte': reporte, 'Publicacion': reporte,'list_grupos': obtenerGrupos(reporte), 'user': request.user}, context_instance=RequestContext(request))

def listarproyectosReportes(request, object_id=0):
    reporte = obtenerReporte(request, object_id)
    tipo = "reporte"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Proyectos '+reporte.reporte,request.path)])
    return render_to_response('Publicaciones/proyectos.html', {'tipo':tipo,'Reporte': reporte, 'Publicacion': reporte,'list_proyectos': reporte.proyectos.all(), 'user': request.user}, context_instance=RequestContext(request))

def listarpartnersReportes(request, object_id=0):
    reporte = obtenerReporte(request, object_id)
    tipo = "reporte"
    request.breadcrumbs([('Publicaciones',reverse(list_all_publications_view)),('Partners '+reporte.reporte,request.path)])
    return render_to_response('Publicaciones/partners.html', {'tipo':tipo,'Reporte': reporte,'Publicacion': reporte, 'list_partners': obtenerPartners(reporte), 'user': request.user}, context_instance=RequestContext(request))

def crearAutores(request, type, pub_id=0):
    response_dict = {}
    pub = None
    if request.method == 'POST':
        f = crearAutoresForms(request.POST)
        if f.is_valid():
            autor_obj = f.save()
            try:
                if type == 'libro':
                    pub = Libros.objects.get(id = pub_id)
                elif type == 'revista':
                    pub = Revistas.objects.get(id = pub_id)
                elif type == 'conferencia':
                    pub = Conferencias.objects.get(id = pub_id)
                elif type == 'tesis':
                    pub = Tesis.objects.get(id = pub_id)
                elif type == 'reporte':  
                    pub = ReportesTecnicos.objects.get(id = pub_id)
                elif type == 'paper':
                    pub = Papers.objects.get(id = pub_id)
            except ObjectDoesNotExist:
                return render_to_response('error.html',{'error':'La publicacion a la que se quiere agregar el autor no existe', 'archivo': 'view de publicaciones', 'linea': 'linea 1389'})

            if puedeEditarPublicacionEspecifica(request.user, pub):
                if autor_obj.tipo == "interno":
                    response_dict.update({'autor': autor_obj.autor_interno.get_full_name()})
                elif autor_obj.tipo == "externo":
                    response_dict.update({'autor': autor_obj.autor_externo})

                response_dict.update({'pos': autor_obj.pos})
                response_dict.update({'value': autor_obj.id})
                response_dict.update({'type':type})

                pub.autores.add(autor_obj)
            else:
                return render_to_response('error.html',{'error':'No tiene los permisos necesarios', 'archivo': 'view de publicaciones', 'linea': 'linea 14448'})
    return HttpResponse(simplejson.dumps(response_dict),mimetype = 'application/javascript')

def borrarAutores(request, type, pub_id=0):
    response_dict = {}
    if request.method == 'POST':
        for autor_id in request.POST.getlist('cargados'):
            try:
                autor_obj = Autores_de_publicaciones.objects.get(id = autor_id)
            except ObjectDoesNotExist:
                return render_to_response('error.html',{'error':'El autor ingresado no existe', 'archivo': 'view de publicaciones', 'linea': 'linea 1409'})

            try:
                if type == 'libro':
                    pub = Libros.objects.get(id = pub_id)
                elif type == 'revista':
                    pub = Revistas.objects.get(id = pub_id)
                elif type == 'conferencia':
                    pub = Conferencias.objects.get(id = pub_id)
                elif type == 'tesis':
                    pub = Tesis.objects.get(id = pub_id)
                elif type == 'reporte':  
                    pub = ReportesTecnicos.objects.get(id = pub_id)
                elif type == 'paper':
                    pub = Papers.objects.get(id = pub_id)
            except ObjectDoesNotExist:
                return render_to_response('error.html',{'error':'La publicacion a la que se quiere agregar el autor no existe', 'archivo': 'view de publicaciones', 'linea': 'linea 1426'})

            if puedeEditarPublicacionEspecifica(request.user, pub):
                if autor_obj.tipo == "interno":
                    response_dict.update({'autor': autor_obj.autor_interno.get_full_name()})
                elif autor_obj.tipo == "externo":
                    response_dict.update({'autor': autor_obj.autor_externo})

                response_dict.update({'pos': autor_obj.pos})
                response_dict.update({'value': autor_obj.id})
                response_dict.update({'type':type})
                
                pub.autores.remove(autor_obj)
                autor_obj.delete()
                
            else: 
                return render_to_response('error.html',{'error':'No tiene los permisos necesarios', 'archivo': 'view de publicaciones', 'linea': 'linea 14448'})
    else:
        pass
    return HttpResponse(simplejson.dumps(response_dict),mimetype = 'application/javascript')
